home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1993 July / InfoMagic USENET CD-ROM July 1993.ISO / sources / misc / volume25 / ted / part06 < prev    next >
Encoding:
Text File  |  1991-11-06  |  53.6 KB  |  1,824 lines
  1. Newsgroups: comp.sources.misc
  2. From: dan%step.uucp@uunet.uu.net (Daniel Weaver)
  3. Subject:  v25i031:  ted - Terminfo/termcap test program, Part06/07
  4. Message-ID: <1991Nov6.043029.6125@sparky.imd.sterling.com>
  5. X-Md4-Signature: ece6574372eada19b576272192a1a955
  6. Date: Wed, 6 Nov 1991 04:30:29 GMT
  7. Approved: kent@sparky.imd.sterling.com
  8.  
  9. Submitted-by: dan%step.uucp@uunet.uu.net (Daniel Weaver)
  10. Posting-number: Volume 25, Issue 31
  11. Archive-name: ted/part06
  12. Environment: UNIX
  13.  
  14. #! /bin/sh
  15. # This is a shell archive.  Remove anything before this line, then feed it
  16. # into a shell via "sh file" or similar.  To overwrite existing files,
  17. # type "sh file -c".
  18. # The tool that generated this appeared in the comp.sources.unix newsgroup;
  19. # send mail to comp-sources-unix@uunet.uu.net if you want that tool.
  20. # If this archive is complete, you will see the following message at the end:
  21. #        "End of archive 6 (of 7)."
  22. # Contents:  modes.c output.c scan.c
  23. # Wrapped by dan@step on Fri Nov  1 11:28:28 1991
  24. PATH=/bin:/usr/bin:/usr/ucb ; export PATH
  25. if test -f 'modes.c' -a "${1}" != "-c" ; then 
  26.   echo shar: Will not clobber existing file \"'modes.c'\"
  27. else
  28. echo shar: Extracting \"'modes.c'\" \(19417 characters\)
  29. sed "s/^X//" >'modes.c' <<'END_OF_FILE'
  30. X/*
  31. X** This software is Copyright (c) 1991 by Daniel Weaver.
  32. X**
  33. X** Permission is hereby granted to copy, distribute or otherwise
  34. X** use any part of this package as long as you do not try to make
  35. X** money from it or pretend that you wrote it.  This copyright
  36. X** notice must be maintained in any copy made.
  37. X**
  38. X** Use of this software constitutes acceptance for use in an AS IS
  39. X** condition. There are NO warranties with regard to this software.
  40. X** In no event shall the author be liable for any damages whatsoever
  41. X** arising out of or in connection with the use or performance of this
  42. X** software.  Any use of this software is at the user's own risk.
  43. X**
  44. X**  If you make modifications to this software that you feel
  45. X**  increases it usefulness for the rest of the community, please
  46. X**  email the changes, enhancements, bug fixes as well as any and
  47. X**  all ideas to me. This software is going to be maintained and
  48. X**  enhanced as deemed necessary by the community.
  49. X*/
  50. X/* this module tests boolian flags and terminal modes */
  51. X
  52. X#include "curses.h"
  53. X#include "ted.h"
  54. X
  55. Xstatic void
  56. Xuprint(s)
  57. Xchar *s;
  58. X   {  /* underline string for (ul) test */
  59. X      if (s)
  60. X         while (*s) {
  61. X            put_str("_\b");
  62. X            putchp(*s++);
  63. X         }
  64. X   }
  65. X
  66. X
  67. X/* Note: uprint() sends underscore back-space character, and
  68. X        ucprint() sends character back-space underscore.  */
  69. X
  70. Xstatic void
  71. Xucprint(s)
  72. Xchar *s;
  73. X   {  /* underline string for (uc) test */
  74. X      if (s)
  75. X         while (*s) {
  76. X            putchp(*s++);
  77. X            putchp('\b');
  78. X            putp(underline_char);
  79. X         }
  80. X   }
  81. X
  82. X
  83. Xstatic void
  84. Xsubtest_tbc()
  85. X   {  /* test clear tabs (tbc) */
  86. X      int i;
  87. X
  88. X      put_clear();
  89. X      putp(clear_all_tabs);
  90. X      ptext("Clear tabs (tbc)");
  91. X      go_home();
  92. X      put_crlf();  putchp('\t');  putchp('T');
  93. X      go_home();
  94. X      put_newlines(2);
  95. X         for (i = 1; i < columns; i++) {
  96. X            putchp('.');
  97. X         }
  98. X      putchp('T');  go_home();
  99. X      ptext("\n\n\nDone. (tbc)");
  100. X   }
  101. X
  102. X
  103. Xstatic void
  104. Xsubtest_hts()
  105. X   {  /* set tabs with (hts), also (xt) glitch */
  106. X      int i, tabat;
  107. X
  108. X      put_clear();
  109. X      tabat = init_tabs;
  110. X      if (set_tab)
  111. X         {
  112. X            ptext("Tabs set with (hts)");
  113. X            put_crlf();
  114. X               for (i = 1; i < columns; i++) {
  115. X                  if (i % 8 == 1) putp(set_tab);
  116. X                  putchp(' ');
  117. X               }
  118. X            tabat = 8;
  119. X         }
  120. X      else
  121. X         {
  122. X            ptext("(hts) not defined.  The following tabs are set:");
  123. X         }
  124. X      go_home();
  125. X      put_newlines(2);
  126. X      if (tabat <= 0) tabat = 8;
  127. X         for (i = tabat; i < columns; i += tabat) {
  128. X            putchp('\t');  putchp('T');
  129. X         }
  130. X      go_home();
  131. X      put_newlines(3);
  132. X         for (i = 1; i < columns; i++) {
  133. X            putchp('.');
  134. X         }
  135. X      go_home();
  136. X      put_newlines(3);
  137. X         for (i = tabat; i < columns; i += tabat) {
  138. X            putchp('\t');  putchp('T');
  139. X         }
  140. X      go_home();
  141. X      put_newlines(4);
  142. X      putchp('.');
  143. X         for (i = 2; i < columns; i++) {
  144. X            if (i % tabat == 1) putchp('T');
  145. X            else putchp('.');
  146. X         }
  147. X      go_home();
  148. X      put_newlines(5);
  149. X      ptextln("The last two lines should be the same.");
  150. X
  151. X#if defined(SVR3) || defined(XENIX)
  152. X      if (!over_strike && (init_tabs > 0 || set_tab))
  153. X         {
  154. X            ptextln("\nDestructive tab test");
  155. X            ptext("(xt) should not ");  put_cr();
  156. X            ptext("(xt) should");
  157. X               while (char_count < 16) {
  158. X                  if (translate_mode && tab) putp(tab);
  159. X                  else putp(TM_tab);
  160. X                  char_count = ((char_count / tabat) + 1) * tabat;
  161. X               }
  162. X            putln("be set.");
  163. X            sprintf(temp, "(xt) is %s in the data base.",
  164. X               dest_tabs_magic_smso ? "true": "false");
  165. X            ptextln(temp);
  166. X         }
  167. X#endif
  168. X   }
  169. X
  170. Xstatic void
  171. Xsubtest_cbt()
  172. X   {  /* test back tab (cbt) */
  173. X      int i;
  174. X
  175. X      if (back_tab)
  176. X         {
  177. X            put_clear();
  178. X            ptext("Back tabs (cbt)");
  179. X            go_home();
  180. X            put_crlf();
  181. X               for (i = 1; i < columns; i++) {
  182. X                  putchp(' ');
  183. X               }
  184. X               for (i = 0; i < columns; i += 8) {
  185. X                  putp(back_tab);  putchp('T');
  186. X                  putp(back_tab);
  187. X               }
  188. X            go_home();
  189. X            put_newlines(2);
  190. X               for (i = 1; i < columns; i++) {
  191. X                  if (i % 8 == 1) putchp('T');
  192. X                  else putchp('.');
  193. X               }
  194. X            go_home();
  195. X            put_newlines(4);
  196. X         }
  197. X      else
  198. X         {
  199. X            if (init_tabs <= 0 && !set_tab)
  200. X               {
  201. X                  /* setupterm() resets (cbt) if both (it) and (hts) are
  202. X                     missing. */
  203. X                  ptextln("(it) and (hts) missing...  (cbt) back tab not tested!");
  204. X               }
  205. X            else ptextln("(cbt) back tab not present");
  206. X         }
  207. X   }
  208. X
  209. X
  210. Xstatic void
  211. Xtest_os_set()
  212. X   {  /* test (am) (smam) (rmam) (xenl) on overstrike terminals */
  213. X      int i, j;
  214. X
  215. X#if defined(SVR3) || defined(XENIX)
  216. X      if (exit_am_mode && can_go_home)
  217. X         {
  218. X            go_home();
  219. X            putp(exit_am_mode);
  220. X            ptext("\n(rmam) will     reset (am)");
  221. X            go_home();
  222. X               for (j = 0; j < columns; j++) put_this(' ');
  223. X            ptext("(rmam) will not reset (am)");
  224. X         }
  225. X      else ptext("(rmam) not present.");
  226. X
  227. X      if (enter_am_mode && can_go_home)
  228. X         {
  229. X            go_home();
  230. X            putp(enter_am_mode);
  231. X            ptext("\n\n\n(smam) will ");
  232. X            i = char_count;
  233. X            ptext("not set (am)");
  234. X            go_home();
  235. X            put_newlines(2);
  236. X               for (j = -i; j < columns; j++) put_this(' ');
  237. X            put_str("@@@");
  238. X         }
  239. X      else ptext("\n\n(smam) not present.");
  240. X#endif
  241. X
  242. X      if (can_go_home)
  243. X         {
  244. X            go_home();
  245. X            ptext("\n\n\n\n\n(am) should ");
  246. X            i = char_count;
  247. X            ptext("not be set");
  248. X            go_home();
  249. X            put_newlines(4);
  250. X               for (j = -i; j < columns; j++) put_this(' ');
  251. X            put_str("@@@");
  252. X            go_home();
  253. X            put_newlines(6);
  254. X         }
  255. X      else put_crlf();
  256. X      sprintf(temp, "(am) is %s in the data base",
  257. X         auto_right_margin ? "true" : "false");
  258. X      ptextln(temp);
  259. X
  260. X      ptext("\n(bw) should ");
  261. X      i = char_count;
  262. X      ptextln("not be set.");
  263. X         for (j = i; j < columns; j++) put_str("\b");
  264. X      put_str("@@@");
  265. X      put_crlf();
  266. X      sprintf(temp, "(bw) is %s in the data base",
  267. X         auto_left_margin ? "true" : "false");
  268. X      ptextln(temp);
  269. X   }
  270. X
  271. X
  272. Xstatic void
  273. Xsubtest_os_xenl()
  274. X   {  /* test (xenl) on overstrike terminals */
  275. X      int i, j, k;
  276. X
  277. X      if (can_go_home && can_clear_screen)
  278. X         {  /* (xenl) test */
  279. X            put_clear();
  280. X            /* this test must be done in raw mode.  Otherwise UNIX
  281. X               will translate CR to CRLF. */
  282. X            if (stty_query(TTY_OUT_TRANS)) tty_raw(1, char_mask);
  283. X            ptext("\nreset (xenl). Does ");
  284. X            i = char_count;
  285. X            put_str("not ignore CR, does ");
  286. X            k = char_count;
  287. X            put_str("not ignore LF");
  288. X            go_home();
  289. X               for (j = 0; j < columns; j++) put_this(' ');
  290. X            put_cr();
  291. X               for (j = 0; j < i; j++) putchp(' ');
  292. X            put_str("@@@\n@@");
  293. X            go_home();
  294. X               for (j = 0; j < columns; j++) put_this(' ');
  295. X            put_lf();
  296. X               for (j = 0; j < k; j++) putchp(' ');
  297. X            put_str("@@@\r@@");
  298. X            tty_set();
  299. X            go_home();
  300. X            put_newlines(4);
  301. X         }
  302. X      else ptextln("\n(xenl) not tested, (clear) (cup) or (home) missing");
  303. X      sprintf(temp, "(xenl) is %s in the data base",
  304. X         eat_newline_glitch ? "true" : "false");
  305. X      ptextln(temp);
  306. X   }
  307. X
  308. X
  309. Xstatic void
  310. Xtest_os_reset()
  311. X   {  /* test (am) (smam) (rmam) (xenl) on non-overstrike terminals */
  312. X      int i, j;
  313. X
  314. X#if defined(SVR3) || defined(XENIX)
  315. X      if (exit_am_mode && can_go_home)
  316. X         {
  317. X            go_home();
  318. X            putp(exit_am_mode);
  319. X            ptext("\n(rmam) will reset (am)");
  320. X            go_home();
  321. X               for (j = 0; j < columns; j++) put_this(' ');
  322. X            ptext("(rmam) will not reset (am) ");
  323. X            go_home();
  324. X            put_str("                          ");
  325. X         }
  326. X      else ptext("(rmam) not present.");
  327. X
  328. X      if (enter_am_mode && can_go_home)
  329. X         {
  330. X            go_home();
  331. X            putp(enter_am_mode);
  332. X            ptext("\n\n\n(smam) will not set (am)");
  333. X            go_home();
  334. X            put_newlines(2);
  335. X               for (j = 0; j < columns; j++) put_this(' ');
  336. X            ptext("(smam) will set (am)    ");
  337. X            go_home();
  338. X            put_str("\n\n                          ");
  339. X         }
  340. X      else ptext("\n\n(smam) not present.");
  341. X#endif
  342. X
  343. X      if (can_go_home)
  344. X         {
  345. X            go_home();
  346. X            ptext("\n\n\n\n\n(am) should not be set");
  347. X            go_home();
  348. X            put_newlines(4);
  349. X               for (j = 0; j < columns; j++) put_this(' ');
  350. X            ptext("(am) should be set    ");
  351. X            go_home();
  352. X            put_str("\n\n\n\n                       \n\n");
  353. X         }
  354. X      else put_crlf();
  355. X      sprintf(temp, "(am) is %s in the data base",
  356. X         auto_right_margin ? "true" : "false");
  357. X      ptextln(temp);
  358. X
  359. X      /* (ul) is used only if (os) is reset */
  360. X      sprintf(temp, "\n(ul) is %s in the data base",
  361. X         transparent_underline ? "true" : "false");
  362. X      ptextln(temp);
  363. X      sprintf(temp, "This text should %sbe underlined.",
  364. X         transparent_underline ? "" : "not ");
  365. X      uprint(temp);
  366. X      put_newlines(2);
  367. X 
  368. X      if (underline_char)
  369. X         {
  370. X            ptextln("Test underline character (uc)");
  371. X            ucprint("This text should be underlined.");
  372. X            put_newlines(2);
  373. X         }
  374. X      else
  375. X      if (!enter_underline_mode)
  376. X         ptextln("(uc) underline character, is not defined\n");
  377. X
  378. X      ptextln("(bw) should not be set.");
  379. X         for (i = 12; i < columns; i++) put_str("\b");
  380. X      if (delete_character)
  381. X         for (i = 0; i < 4; i++) putp(delete_character);
  382. X      else put_str("   ");
  383. X      put_crlf();
  384. X      sprintf(temp, "(bw) is %s in the data base",
  385. X         auto_left_margin ? "true" : "false");
  386. X      ptextln(temp);
  387. X   }
  388. X
  389. X
  390. Xstatic void
  391. Xsubtest_xenl()
  392. X   {  /* test (xenl) when (os) is reset */
  393. X      int j;
  394. X
  395. X      if (can_go_home)
  396. X         {  /* (xenl) test */
  397. X            put_clear();
  398. X            /* this test must be done in raw mode.  Otherwise UNIX
  399. X               will translate CR to CRLF. */
  400. X            if (stty_query(TTY_OUT_TRANS)) tty_raw(1, char_mask);
  401. X               for (j = 0; j < columns; j++) put_this(' ');
  402. X            put_cr();
  403. X            ptext("(xenl) should be set. Does not ignore CR");
  404. X            go_home();
  405. X            put_crlf();
  406. X               for (j = 0; j < columns; j++) put_this(' ');
  407. X            put_lf();  /* test (cud1) */
  408. X            ptext("(xenl) should be set. Ignores (cud1)");
  409. X            go_home();
  410. X            put_newlines(3);
  411. X            if (scroll_forward && cursor_down &&
  412. X               strcmp(scroll_forward, cursor_down))
  413. X               {
  414. X                     for (j = 0; j < columns; j++) put_this(' ');
  415. X                  put_ind();  /* test (ind) */
  416. X                  ptext("(xenl) should be set. Ignores (ind)");
  417. X                  go_home();
  418. X                  put_newlines(5);
  419. X               }
  420. X            tty_set();
  421. X            ptextln("If the above lines are blank then (xenl) should be false");
  422. X         }
  423. X      else ptextln("(xenl) not tested, (clear) (cup) or (home) missing");
  424. X      sprintf(temp, "(xenl) is %s in the data base",
  425. X         eat_newline_glitch ? "true" : "false");
  426. X      ptextln(temp);
  427. X   }
  428. X
  429. X
  430. Xtest_mode()
  431. X   {
  432. X      int i, j;
  433. X      char *s;
  434. X
  435. X      new_test(3);
  436. X      if (run_mode("(os)"))
  437. X         do {
  438. X            ptext("\n(os) should be true, not false.");  put_cr();
  439. X            ptextln("(os) should be           false.");
  440. X            sprintf(temp, "(os) is %s in the data base",
  441. X               over_strike ? "true" : "false");
  442. X            ptextln(temp);
  443. X         } while (repeat_test(FALSE));
  444. X
  445. X      if (run_mode("(smam)(rmam)(ul)(uc)(am)(bw)"))
  446. X         do {
  447. X            put_clear();
  448. X            if (over_strike) test_os_set();
  449. X            else test_os_reset();
  450. X         } while (repeat_test(FALSE));
  451. X
  452. X      if (run_mode("(xenl)(eo)(xmc)(xhp)"))
  453. X         do {
  454. X            if (over_strike) subtest_os_xenl();
  455. X            else subtest_xenl();
  456. X
  457. X            if (transparent_underline || over_strike || underline_char)
  458. X               {  /* test (eo) */
  459. X                  sprintf(temp, "\n(eo) is %s in the data base",
  460. X                     erase_overstrike ? "true" : "false");
  461. X                  ptextln(temp);
  462. X                  ptext("(eo) should ");
  463. X                  if (underline_char) ucprint("not");
  464. X                  else uprint("not");
  465. X                  put_cr();
  466. X                  ptextln("(eo) should     be set");
  467. X               }
  468. X
  469. X            if (enter_standout_mode)
  470. X               {
  471. X                  sprintf(temp, "\n(xmc) is %d", magic_cookie_glitch);
  472. X                  ptextln(temp);
  473. X                  j = magic_cookie_glitch * 8;
  474. X                     for (i = 0; i < j; i++) put_str(" ");
  475. X                  ptextln("        These two lines should line up.");
  476. X                  if (j > 0) char_count += j;
  477. X                     for (i = 0; i < 4; i++) {
  478. X                        put_mode(enter_standout_mode);
  479. X                        putchp(' ');
  480. X                        put_mode(exit_standout_mode);
  481. X                        putchp(' ');
  482. X                     }
  483. X                  ptextln("These two lines should line up.");
  484. X      
  485. X                  /* test (xhp) */
  486. X                  put_crlf();  put_mode(enter_standout_mode);
  487. X                  put_str("Stand out");  put_mode(exit_standout_mode);
  488. X                  put_cr();
  489. X                  ptextln("If any part of this line is standout then (xhp) should be set.");
  490. X                  sprintf(temp, "(xhp) is %s in the data base",
  491. X                     ceol_standout_glitch ? "true" : "false");
  492. X                  ptextln(temp);
  493. X               }
  494. X         } while (repeat_test(FALSE));
  495. X
  496. X      if (run_test(cursor_address,
  497. X         "(mir) and (msgr) not tested because (cup) is missing", FALSE))
  498. X         do {
  499. X            put_clear();
  500. X            if (enter_insert_mode != (char *)0 &
  501. X               exit_insert_mode != (char *)0)
  502. X               {
  503. X                  ptextln("If the block of X's are square then (mir) should be set. (smir) (rmir) (cup)");
  504. X                  i = line_count;
  505. X                  put_str("\nXXX\nXXX\nXXX\nXXX");
  506. X                  putp(enter_insert_mode);
  507. X                  s = tcup(cursor_address, i + 1, 0);
  508. X                  tputs(s, lines, putch);
  509. X                  putchp('x');
  510. X                  s = tcup(cursor_address, i + 2, 1);
  511. X                  tputs(s, lines, putch);
  512. X                  putchp('x');
  513. X                  s = tcup(cursor_address, i + 3, 2);
  514. X                  tputs(s, lines, putch);
  515. X                  putchp('x');
  516. X                  s = tcup(cursor_address, i + 4, 3);
  517. X                  tputs(s, lines, putch);
  518. X                  putchp('x');
  519. X                  putp(exit_insert_mode);
  520. X                  put_crlf();
  521. X               }
  522. X            else ptextln("(smir) (rmir) not present. (mir) not tested.");
  523. X            if ((enter_standout_mode && exit_standout_mode) ||
  524. X               (enter_alt_charset_mode && exit_alt_charset_mode))
  525. X               {
  526. X                  put_crlf();
  527. X                  ptext("If you see a diagonal line of standout X's then (msgr) should be set, if any of the blanks are standout then (msgr) should be reset. (smacs) (rmacs) (cup)");
  528. X                  i = line_count + 1;
  529. X                  tputs(tcup(cursor_address, i, 0), lines, putch);
  530. X                  put_mode(enter_alt_charset_mode);
  531. X                  put_crlf();
  532. X                  /* some versions of the wy-120 can not clear lines or
  533. X                     screen when in alt charset mode.  If (el) and (ed)
  534. X                     are defined then I can test them.  If they are not
  535. X                     defined then they can not break (msgr) */
  536. X                  putp(clr_eos);
  537. X                  putp(clr_eol);
  538. X                  put_mode(exit_alt_charset_mode);
  539. X                  put_mode(enter_standout_mode);
  540. X                  putchp('X');
  541. X                  tputs(tcup(cursor_address, i + 2, 1), lines, putch);
  542. X                  putchp('X');
  543. X                  tputs(tcup(cursor_address, i + 3, 2), lines, putch);
  544. X                  putchp('X');
  545. X                  tputs(tcup(cursor_address, i + 4, 3), lines, putch);
  546. X                  putchp('X');
  547. X                  put_mode(exit_standout_mode);
  548. X                  put_crlf();
  549. X                  putp(clr_eos);  /* OK if missing */
  550. X                  put_crlf();
  551. X               }
  552. X            else ptextln("(smso) (rmso) (smacs) (rmacs) not present. (msgr) not tested.");
  553. X            sprintf(temp, "(mir) is %s and (msgr) is %s in the data base",
  554. X               move_insert_mode ? "true" : "false",
  555. X               move_standout_mode ? "true" : "false");
  556. X            ptextln(temp);
  557. X         } while (repeat_test(FALSE));
  558. X
  559. X      if (run_test(clear_all_tabs,
  560. X         "Clear all tabs (tbc) not defined.", TRUE))
  561. X         do {
  562. X            subtest_tbc();
  563. X         } while (repeat_test(FALSE));
  564. X
  565. X      if (run_mode("(hts)(xt)"))
  566. X         do {
  567. X            subtest_hts();
  568. X         } while (repeat_test(FALSE));
  569. X
  570. X      if (run_mode("(cbt)(in)"))
  571. X         do {
  572. X            subtest_cbt();
  573. X
  574. X            if (enter_insert_mode && exit_insert_mode)
  575. X               {  /* test (in) */
  576. X                  ptextln("\nTesting (in) with (smir) and (rmir)");
  577. X                  putln("\tIf these two lines line up ...");
  578. X                  put_str("\tIf these two lines line up ...");
  579. X                  put_cr();
  580. X                  putp(enter_insert_mode);
  581. X                  putchp(' ');
  582. X                  putp(exit_insert_mode);
  583. X                  ptext("\nthen (in) should be set.  ");
  584. X                  sprintf(temp,
  585. X                     "(in) is %s in the data base.",
  586. X                     insert_null_glitch ? "true" : "false");
  587. X                  ptextln(temp);
  588. X               }
  589. X         } while (repeat_test(FALSE));
  590. X
  591. X      if (run_mode("(da)(db)")
  592. X         && can_clear_screen && scroll_reverse && scroll_forward)
  593. X         do {  /* test (da) and (db) */
  594. X            put_clear();
  595. X            if (scroll_reverse) ptext("(da) should be set\r");
  596. X            move_to(0, 0, lines - 1, 0, 3);
  597. X            if (scroll_forward) ptext("(db) should be set\r");
  598. X            putp(scroll_forward);
  599. X            move_to(lines - 1, 0, 0, 0, 3);
  600. X            putp(scroll_reverse);
  601. X            putp(scroll_reverse);
  602. X            move_to(0, 0, lines - 1, 0, 3);
  603. X            putp(scroll_forward);
  604. X            move_to(lines - 1, 0, 0, 0, 3);
  605. X            ptextln("\n\n\n\n\nIf the top line is blank then (da) should be false.");
  606. X            ptextln("If the bottom line is blank then (db) should be false.");
  607. X            sprintf(temp, "\n(da) is %s, and (db) is %s, in the data base.",
  608. X            memory_above ? "true" : "false",
  609. X            memory_below ? "true" : "false");
  610. X            ptextln(temp);
  611. X            line_count = lines;
  612. X         } while (repeat_test(FALSE));
  613. X   }
  614. END_OF_FILE
  615. if test 19417 -ne `wc -c <'modes.c'`; then
  616.     echo shar: \"'modes.c'\" unpacked with wrong size!
  617. fi
  618. # end of 'modes.c'
  619. fi
  620. if test -f 'output.c' -a "${1}" != "-c" ; then 
  621.   echo shar: Will not clobber existing file \"'output.c'\"
  622. else
  623. echo shar: Extracting \"'output.c'\" \(23144 characters\)
  624. sed "s/^X//" >'output.c' <<'END_OF_FILE'
  625. X/*
  626. X** This software is Copyright (c) 1991 by Daniel Weaver.
  627. X**
  628. X** Permission is hereby granted to copy, distribute or otherwise
  629. X** use any part of this package as long as you do not try to make
  630. X** money from it or pretend that you wrote it.  This copyright
  631. X** notice must be maintained in any copy made.
  632. X**
  633. X** Use of this software constitutes acceptance for use in an AS IS
  634. X** condition. There are NO warranties with regard to this software.
  635. X** In no event shall the author be liable for any damages whatsoever
  636. X** arising out of or in connection with the use or performance of this
  637. X** software.  Any use of this software is at the user's own risk.
  638. X**
  639. X**  If you make modifications to this software that you feel
  640. X**  increases it usefulness for the rest of the community, please
  641. X**  email the changes, enhancements, bug fixes as well as any and
  642. X**  all ideas to me. This software is going to be maintained and
  643. X**  enhanced as deemed necessary by the community.
  644. X*/
  645. X/* terminfo test program common subroutines */
  646. X
  647. X#include "curses.h"
  648. X#include "ted.h"
  649. X
  650. Xstatic char *c0[32] = {"NUL", "SOH", "STX", "ETX", "EOT", "ENQ", "ACK",
  651. X   "BEL", "BS", "HT", "LF", "VT", "FF", "CR", "SO", "SI",
  652. X   "DLE", "DC1", "DC2", "DC3", "DC4", "NAK", "SYN", "ETB",
  653. X   "CAN", "EM", "SUB", "ESC", "FS", "GS", "RS", "US"};
  654. X
  655. Xstatic char *c1[32] = {"", "", "", "", "IND", "NEL", "SSA", "ESA",
  656. X   "HTS", "HTJ", "VTS", "PLD", "PLU", "RI", "SS2", "SS3",
  657. X   "DCS", "PU1", "PU2", "STS", "CCH", "MW", "SPA", "EPA",
  658. X   "", "", "", "CSI", "ST", "OSC", "PM", "APC"};
  659. X
  660. X/* these data structures keep tabs on which capibilities can be tested
  661. X   by this program.  Entries in this table are terminfo names. */
  662. X#define NP_SIZE 16
  663. Xstatic char ns[4096];  /* storage space for the actual names */
  664. Xstatic char *np[NP_SIZE];  /* pointers into ns[] sorted by length */
  665. X
  666. Xint
  667. Xgetnext(mask)
  668. Xint mask;
  669. X   {  /* get the next character without scan mode conversion */
  670. X      int ch;
  671. X      unsigned char buf;
  672. X
  673. X#ifdef SVR3_2
  674. X      putp(req_for_input);
  675. X#endif
  676. X      fflush(stdout);
  677. X      if (nodelay_read)
  678. X         while (1) {
  679. X            ch = read(fileno(stdin), &buf, 1);
  680. X            if (ch == -1) return EOF;
  681. X            if (ch == 1) return buf;
  682. X         }
  683. X      ch = getchar();
  684. X      if (ch == EOF) return EOF;
  685. X      return ch & mask;
  686. X   }
  687. X
  688. X
  689. Xint
  690. Xgetchp(mask)
  691. Xint mask;
  692. X   {  /* read a character with scan mode conversion */
  693. X      if (scan_mode)
  694. X         {
  695. X#ifdef SVR3_2
  696. X            putp(req_for_input);
  697. X#endif
  698. X            fflush(stdout);
  699. X            return scan_key();
  700. X         }
  701. X      else return getnext(mask);
  702. X   }
  703. X
  704. X
  705. Xvoid
  706. Xputch(c)
  707. Xint c;
  708. X   {  /* output one character */
  709. X      char_sent++;
  710. X      putchar(c);
  711. X   }
  712. X
  713. X
  714. Xvoid
  715. Xput_this(c)
  716. Xint c;
  717. X   {  /* output one character (with padding) */
  718. X      putch(c);
  719. X      if (char_padding && replace_mode) putp(char_padding);
  720. X   }
  721. X
  722. X
  723. Xvoid
  724. Xput_cr()
  725. X   {
  726. X      if (translate_mode && carriage_return)
  727. X         tputs(carriage_return, char_count, putch);
  728. X      else tputs(TM_carriage_return, char_count, putch);
  729. X      char_count = 0;
  730. X   }
  731. X
  732. X
  733. Xvoid
  734. Xput_lf()
  735. X   {  /* send a linefeed (only works in RAW or CBREAK mode) */
  736. X      if (translate_mode && cursor_down) putp(cursor_down);
  737. X      else putp(TM_cursor_down);
  738. X      line_count++;
  739. X   }
  740. X
  741. X
  742. Xvoid
  743. Xput_ind()
  744. X   {  /* scroll forward (only works in RAW or CBREAK mode) */
  745. X      if (translate_mode && scroll_forward) putp(scroll_forward);
  746. X      else putp(TM_scroll_forward);
  747. X      line_count++;
  748. X   }
  749. X
  750. X
  751. Xvoid
  752. Xput_crlf()
  753. X   {  /* send carriage return, linefeed */
  754. X      if (translate_mode && newline) putp(newline);
  755. X      else putp(TM_newline);
  756. X      char_count = 0;
  757. X      line_count++;
  758. X   }
  759. X
  760. X
  761. Xvoid
  762. Xput_newlines(n)
  763. Xint n;
  764. X   {  /* put n newlines */
  765. X         while (n-- > 0) {
  766. X            put_crlf();
  767. X         }
  768. X   }
  769. X
  770. X
  771. Xvoid
  772. Xputchp(c)
  773. Xchar c;
  774. X   {  /* send a character to the terminal */
  775. X      switch (c) {
  776. X         case '\b':
  777. X            if (translate_mode && cursor_left) putp(cursor_left);
  778. X            else putp(TM_cursor_left);
  779. X            char_count--;
  780. X            break;
  781. X         case 7:
  782. X            if (translate_mode && bell) putp(bell);
  783. X            else putp(TM_bell);
  784. X            break;
  785. X         case '\f':
  786. X            if (translate_mode && form_feed) putp(form_feed);
  787. X            else putp(TM_form_feed);
  788. X            char_count = 0;
  789. X            line_count++;
  790. X            break;
  791. X         case '\n':
  792. X            put_crlf();
  793. X            break;
  794. X         case '\r':
  795. X            put_cr();
  796. X            break;
  797. X         case '\t':
  798. X            if (translate_mode && tab) putp(tab);
  799. X            else putp(TM_tab);
  800. X            char_count = ((char_count / 8) + 1) * 8;
  801. X            break;
  802. X         default:
  803. X            put_this(c);
  804. X            char_count++;
  805. X            break;
  806. X      }
  807. X   }
  808. X
  809. X
  810. Xvoid
  811. Xput_str(s)
  812. Xchar *s;
  813. X   {  /* send the string to the terminal */
  814. X      for (; *s; putchp(*s++));
  815. X   }
  816. X
  817. X
  818. Xvoid
  819. Xput_columns(s, len, w)
  820. Xchar *s;
  821. Xint len, w;
  822. X   {  /* put out s in column format */
  823. X      int l;
  824. X
  825. X      if (char_count + w > columns) put_crlf();
  826. X      l = char_count % w;
  827. X      if (l)
  828. X         while (l < w) {
  829. X            putchp(' ');
  830. X            l++;
  831. X         }
  832. X      if (char_count && char_count + len >= columns) put_crlf();
  833. X      l = char_count;
  834. X      put_str(s);
  835. X      char_count = l + len;
  836. X   }
  837. X
  838. X
  839. Xvoid
  840. Xputln(s)
  841. Xchar *s;
  842. X   {  /* output a string followed by a CR LF */
  843. X      for (; *s; putchp(*s++));
  844. X      put_crlf();
  845. X   }
  846. X
  847. X
  848. Xvoid
  849. Xptext(s)
  850. Xchar *s;
  851. X   {  /* output a string but do not assume the terminal will wrap
  852. X         to a new line.  Break the line at a word boundry then send
  853. X         a CR LF.  This is more estetic on 40 column terminals. */
  854. X      char *t, *x;
  855. X
  856. X      while (*s) {
  857. X            for (t = s + 1; *t > ' '; t++) ;
  858. X         if (char_count != 0 & (t - s) + char_count >= columns) {
  859. X               put_crlf();
  860. X               while (*s == ' ') s++;
  861. X         }
  862. X#ifdef TESTCAP
  863. X         /* We use terminfo in the text and convert it to termcap
  864. X            at the very last moment.  The conversion is done on the
  865. X            fly because termcap has no standard and the name may change
  866. X            from one application to the next.  */
  867. X            for (x = t - 1; x > s; x--)
  868. X               if (*x == ')')
  869. X                  while (s < t) {
  870. X                     if (*s == '(')
  871. X                        {  /* convert terminfo names to termcap names */
  872. X                           int i;
  873. X
  874. X                           i = cap_index(s + 1, x - s - 1);
  875. X                           if (i >= 0)
  876. X                              {
  877. X                                 putchp(LEFT_BRACE);
  878. X                                 put_str(&captrans[i][x - s]);
  879. X                                 putchp(RIGHT_BRACE);
  880. X                                 s = x + 1;
  881. X                              }
  882. X                           break;
  883. X                        }
  884. X                     else putchp(*s++);
  885. X                  }
  886. X#endif
  887. X            while (s < t) {
  888. X               putchp(*s++);
  889. X            }
  890. X      }
  891. X   }
  892. X
  893. X
  894. Xvoid
  895. Xput_dec(f, i)
  896. Xchar *f;
  897. Xint i;
  898. X   {  /* print a line with a decimal number in it */
  899. X      char tm[128];
  900. X
  901. X      sprintf(tm, f, i / 10, i % 10);
  902. X      ptext(tm);
  903. X   }
  904. X
  905. X
  906. Xvoid
  907. Xthree_digit(tx, i)
  908. Xchar *tx;
  909. Xint i;
  910. X   {  /* convert the decimal number to a string of at least 3 digits */
  911. X      if (i < 1000)
  912. X         sprintf(tx, "%d.%d", i / 10, i % 10);
  913. X      else sprintf(tx, "%d", i / 10);
  914. X   }
  915. X
  916. X
  917. Xvoid
  918. Xptextln(s)
  919. Xchar *s;
  920. X   {  /* print the text using ptext() then add a CR LF */
  921. X      ptext(s);
  922. X      put_crlf();
  923. X   }
  924. X
  925. X
  926. Xstatic void
  927. Xexpand_one(ch, v)
  928. Xint ch;
  929. Xchar **v;
  930. X   {   /* expand one character */
  931. X      char *t = *v;
  932. X
  933. X      if (ch & 0x80)
  934. X         {  /* dump it in octal (yuck) */
  935. X            *t++ = '\\';
  936. X            *t++ = '0' + ((ch >> 6) & 3);
  937. X            *t++ = '0' + ((ch >> 3) & 7);
  938. X            *t++ = '0' + (ch & 7);
  939. X            expand_chars += 4;
  940. X         }
  941. X      else
  942. X      if (ch == 127)
  943. X         {  /* DEL */
  944. X            *t++ = '^';  *t++ = '?';
  945. X            expand_chars += 2;
  946. X         }
  947. X      else
  948. X      if (ch >= ' ')
  949. X         {
  950. X            *t++ = ch;
  951. X            expand_chars++;
  952. X         }
  953. X      else
  954. X         {  /* control characters */
  955. X            *t++ = '^';  *t++ = ch + '@';
  956. X            expand_chars += 2;
  957. X         }
  958. X      *v = t;
  959. X   }
  960. X
  961. X
  962. Xchar *
  963. Xexpand(s)
  964. Xchar *s;
  965. X   {  /* convert the string to printable form */
  966. X      static char buf[4096];
  967. X      char *t, *v;
  968. X      int ch;
  969. X
  970. X      if (magic_cookie_glitch <= 0 && exit_attribute_mode)
  971. X         v = enter_reverse_mode;
  972. X      else v = NULL;
  973. X
  974. X      expand_chars = 0;
  975. X      t = buf;
  976. X      if (s)
  977. X         for ( ; ch = *s; s++) {
  978. X            if ((ch & 0x80) && v)
  979. X               {  /* print it in reverse video mode */
  980. X#ifdef SVR3_2
  981. X                  strcpy(t, liberated(tparm(v)));
  982. X#else
  983. X                  strcpy(t, liberated(v));
  984. X#endif
  985. X                     for ( ; *t; t++);
  986. X                  expand_one(ch & 0x7f, &t);
  987. X#ifdef SVR3_2
  988. X                  strcpy(t, liberated(tparm(exit_attribute_mode)));
  989. X#else
  990. X                  strcpy(t, liberated(exit_attribute_mode));
  991. X#endif
  992. X                     for ( ; *t; t++);
  993. X               }
  994. X            else expand_one(ch, &t);
  995. X         }
  996. X      *t = '\0';
  997. X      return buf;
  998. X   }
  999. X
  1000. X
  1001. Xchar *
  1002. Xprint_expand(s)
  1003. Xchar *s;
  1004. X   {  /* convert the string to 7-bit printable form */
  1005. X      static char buf[4096];
  1006. X      char *t;
  1007. X      int ch;
  1008. X
  1009. X      expand_chars = 0;
  1010. X      t = buf;
  1011. X      if (s)
  1012. X         for ( ; ch = *s; s++) {
  1013. X            expand_one(ch, &t);
  1014. X         }
  1015. X      *t = '\0';
  1016. X      return buf;
  1017. X   }
  1018. X
  1019. X
  1020. Xchar *
  1021. Xexpand_to(s, l)
  1022. Xchar *s;
  1023. Xint l;
  1024. X   {  /* expand s to length l */
  1025. X      char *t;
  1026. X
  1027. X         for (s = t = expand(s); *t; t++)
  1028. X            ;
  1029. X         for ( ; expand_chars < l; expand_chars++) {
  1030. X            *t++ = ' ';
  1031. X         }
  1032. X      *t = '\0';
  1033. X      return s;
  1034. X   }
  1035. X
  1036. X
  1037. Xchar *
  1038. Xhex_expand_to(s, l)
  1039. Xchar *s;
  1040. Xint l;
  1041. X   {  /* expand s to length l in hex */
  1042. X      static char buf[128];
  1043. X      char *t;
  1044. X
  1045. X         for (t = buf; *s; s++) {
  1046. X            sprintf(t, "%02X ", *s & 0xff);
  1047. X            t += 3;
  1048. X         }
  1049. X         for ( ; t - buf < l; ) {
  1050. X            *t++ = ' ';
  1051. X         }
  1052. X      *t = '\0';
  1053. X      expand_chars = t - buf;
  1054. X      return buf;
  1055. X   }
  1056. X
  1057. X
  1058. Xchar *
  1059. Xexpand_command(c)
  1060. Xchar *c;
  1061. X   {  /* expand an ANSI escape sequence */
  1062. X      static char buf[256];
  1063. X      int i, j, ch;
  1064. X      char *s;
  1065. X
  1066. X      s = buf;
  1067. X         for (i = FALSE; ch = (*c & 0xff); c++) {
  1068. X            if (i) *s++ = ' ';
  1069. X            i = TRUE;
  1070. X            if (ch < 32)
  1071. X               {
  1072. X                  j = c[1] & 0xff;
  1073. X                  if (ch == A_ESC && j >= '@' && j <= '_')
  1074. X                     {
  1075. X                        ch = j - '@';
  1076. X                        c++;
  1077. X                           for (j = 0; *s = c1[ch][j++]; s++);
  1078. X                     }
  1079. X                  else
  1080. X                     for (j = 0; *s = c0[ch][j++]; s++);
  1081. X               }
  1082. X            else
  1083. X               {
  1084. X                  *s++ = ch;
  1085. X                  j = c[1] & 0xff;
  1086. X                  if (ch >= '0' && ch <= '9' &&
  1087. X                      j >= '0' && j <= '9') i = FALSE;
  1088. X               }
  1089. X         }
  1090. X      *s = '\0';
  1091. X      return buf;
  1092. X   }
  1093. X
  1094. X
  1095. Xvoid
  1096. Xgo_home()
  1097. X   {  /* move the cursor to the home position */
  1098. X      int i;
  1099. X
  1100. X      if (cursor_home) putp(cursor_home);
  1101. X      else
  1102. X      if (cursor_address) 
  1103. X         tputs(tcup(cursor_address, 0, 0), lines, putch);
  1104. X      else
  1105. X      if (row_address)
  1106. X         {  /* use (vpa) */
  1107. X            put_cr();
  1108. X            tputs(tparm(row_address, 0), 1, putch);
  1109. X         }
  1110. X      else
  1111. X      if (cursor_up && cursor_to_ll)
  1112. X         {
  1113. X            putp(cursor_to_ll);
  1114. X            for (i = 1; i < lines; i++) putp(cursor_up);
  1115. X         }
  1116. X      else
  1117. X         {
  1118. X            can_go_home = FALSE;
  1119. X            return;
  1120. X         }
  1121. X      char_count = line_count = 0;
  1122. X      can_go_home = TRUE;
  1123. X   }
  1124. X
  1125. X
  1126. Xvoid
  1127. Xhome_down()
  1128. X   {  /* move the cursor to the lower left hand corner */
  1129. X      int i;
  1130. X
  1131. X      if (cursor_to_ll) putp(cursor_to_ll);
  1132. X      else
  1133. X      if (cursor_address) 
  1134. X         tputs(tcup(cursor_address, lines - 1, 0), lines, putch);
  1135. X      else
  1136. X      if (row_address)
  1137. X         {  /* use (vpa) */
  1138. X            put_cr();
  1139. X            tputs(tparm(row_address, lines - 1), 1, putch);
  1140. X         }
  1141. X      else
  1142. X      if (cursor_down && cursor_home)
  1143. X         {
  1144. X            putp(cursor_home);
  1145. X               for (i = 1; i < lines; i++) putp(cursor_down);
  1146. X         }
  1147. X      else return;
  1148. X      char_count = 0;
  1149. X      line_count = lines - 1;
  1150. X   }
  1151. X
  1152. X
  1153. Xvoid
  1154. Xput_clear()
  1155. X   {  /* clear the screen */
  1156. X      int i;
  1157. X
  1158. X      if (clear_screen) tputs(clear_screen, lines, putch);
  1159. X      else
  1160. X      if (clr_eos && can_go_home)
  1161. X         {
  1162. X            go_home();  
  1163. X            tputs(clr_eos, lines, putch);
  1164. X         }
  1165. X      else
  1166. X      if (scroll_forward && !over_strike && (can_go_home || cursor_up))
  1167. X         {
  1168. X            /* clear the screen by scrolling */
  1169. X            put_cr();
  1170. X            if (cursor_to_ll) putp(cursor_to_ll);
  1171. X            else
  1172. X            if (cursor_address) 
  1173. X               tputs(tcup(cursor_address, lines - 1, 0), lines, putch);
  1174. X            else
  1175. X            if (row_address)
  1176. X                  tputs(tparm(row_address, lines - 1), 1, putch);
  1177. X            else for (i = 1; i < lines; i++) putp(scroll_forward);
  1178. X
  1179. X            for (i = 1; i < lines; i++) putp(scroll_forward);
  1180. X
  1181. X            if (can_go_home) go_home();
  1182. X            else for (i = 1; i < lines; i++) putp(cursor_up);
  1183. X         }
  1184. X      else
  1185. X         {
  1186. X            can_clear_screen = FALSE;
  1187. X            return;
  1188. X         }
  1189. X      char_count = line_count = 0;
  1190. X      can_clear_screen = TRUE;
  1191. X   }
  1192. X
  1193. X
  1194. Xint
  1195. Xtty_sync_error()
  1196. X{   /* send an ENQ and wait for the ACK */
  1197. X      int ch, ct, trouble, ack;
  1198. X      long read_time;
  1199. X
  1200. X      trouble = FALSE;
  1201. X         for ( ; ; ) {
  1202. X            putp(tty_ENQ);  /* send ENQ */
  1203. X            ch = getnext(STRIP_PARITY);
  1204. X            read_time = time(0);  /* start the timer */
  1205. X            tty_ACK[ack = 0] = ch;
  1206. X               for (ct = junk_chars; ct > 0; ct--) {
  1207. X                  if (ch == ACK_char) return trouble;
  1208. X                  ch = getnext(STRIP_PARITY);
  1209. X                  if (ack < TTY_ACK_SIZE - 1) tty_ACK[++ack] = ch;
  1210. X               }
  1211. X            tty_ACK[ack + 1] = '\0';
  1212. X            if (ch == ACK_char) return trouble;
  1213. X            if (tty_can_sync != 2)
  1214. X               {  /* called from verify_time() */
  1215. X                  put_crlf();
  1216. X                  putln("Terminal did not respond to ENQ");
  1217. X                  tty_can_sync = FALSE;
  1218. X                  return (ch | 4096);
  1219. X               }
  1220. X            /* If we get here the terminal is sending too many
  1221. X               characters.  The trick is to find out if the characters
  1222. X               are comming from the terminal or the user.  We assume
  1223. X               the terminal will send only while it is processing
  1224. X               commands in its buffer, and that the buffer will empty
  1225. X               in a short poriod of time.  Any characters sent after
  1226. X               a few seconds must be from the user.  */
  1227. X
  1228. X               do {
  1229. X                  ch = getchp(STRIP_PARITY);
  1230. X                  if (time(0) - read_time > 3)
  1231. X                     {
  1232. X                        putchp(7);  /* ring the bell */
  1233. X                        break;
  1234. X                     }
  1235. X               } while (ch != 'c' && ch != 'C');
  1236. X            set_attr(0);  /* just in case */
  1237. X            putln(" -- synch -- ");
  1238. X            trouble = TRUE;
  1239. X         }
  1240. X   }
  1241. X
  1242. X
  1243. Xint
  1244. Xenq_ack()
  1245. X   {  /* send an ENQ, get an ACK */
  1246. X      int sync_error;
  1247. X
  1248. X         for (sync_error = 0; tty_sync_error(); sync_error++) {
  1249. X            sleep(1);
  1250. X            if (sync_error > 2)
  1251. X               {
  1252. X                  ptext("\nPad processing terminated...");
  1253. X                  (void) wait_here();
  1254. X                  time_pad = FALSE;
  1255. X                  return FALSE;
  1256. X               }
  1257. X         }
  1258. X      char_sent = 0;
  1259. X      start_time = time(0);
  1260. X      return TRUE;
  1261. X   }
  1262. X
  1263. X
  1264. Xint
  1265. Xwait_here()
  1266. X   {  /* read one character from the input stream */
  1267. X      char ch, cc[64];
  1268. X      char message[16];
  1269. X      int i, j;
  1270. X
  1271. X      /* Wait for CR or LF if we are not in RAW mode */
  1272. X         for (i = 0; ; i++) {
  1273. X            cc[i] = ch = getchp(STRIP_PARITY);
  1274. X            if (ch == '\r' | ch == '\n')
  1275. X               {
  1276. X                  put_crlf();
  1277. X                  char_sent = 0;
  1278. X                  return cc[i ? i - 1 : 0];
  1279. X               }
  1280. X            if (ch >= ' ')
  1281. X               {
  1282. X                  if (stty_query(TTY_CHAR_MODE))
  1283. X                     {
  1284. X                        put_crlf();
  1285. X                        char_sent = 0;
  1286. X                        return ch;
  1287. X                     }
  1288. X                  continue;
  1289. X               }
  1290. X            if (ch == 023)  /* Control S */
  1291. X               {
  1292. X                  /* ignore control S, but tell me about it */
  1293. X                     while (ch == 023 | ch == 021) {
  1294. X                        ch = getchp(STRIP_PARITY);
  1295. X                        if (i < sizeof(cc)) cc[++i] = ch;
  1296. X                     }
  1297. X                  put_str("\nThe terminal sent a ^S -");
  1298. X                     for (j = 0; j <= i; j++) {
  1299. X                        sprintf(message, " %02X", cc[j] & 0xFF);
  1300. X                        put_str(message);
  1301. X                     }
  1302. X                  put_crlf();
  1303. X                  i = -1;
  1304. X               }
  1305. X            else
  1306. X            if (ch != 021)  /* Control Q */
  1307. X               { /* could be abort character */
  1308. X                  sleep(1);
  1309. X                  if (tty_can_sync == 2)
  1310. X                     for (j = 1; j < 5; j++) {
  1311. X                        if (!tty_sync_error()) break;
  1312. X                        sleep(1);
  1313. X                     }
  1314. X                  put_str("\nHit 'c' to continue");
  1315. X                  ch = getchp(STRIP_PARITY);
  1316. X                  put_crlf();
  1317. X                  if (ch != 'c' & ch != 'C') bye_kids(1);
  1318. X                  char_sent = 0;
  1319. X                  return ch;
  1320. X               }
  1321. X         }
  1322. X   }
  1323. X
  1324. X
  1325. Xmaybe_wait(n)
  1326. Xint n;
  1327. X   {  /* wait if near the end of the screen, then clear screen */
  1328. X      if (line_count + n >= lines)
  1329. X         {
  1330. X            if (char_sent != 0) (void) wait_here();
  1331. X            put_clear();
  1332. X         }
  1333. X      else put_crlf();
  1334. X   }
  1335. X
  1336. X
  1337. Xnew_test(n)
  1338. Xint n;
  1339. X   {  /* if I have room, begin the test else clear the screen */
  1340. X      /* this function is used after a call to wait_here() */
  1341. X      if (line_count + n >= lines) put_clear();
  1342. X   }
  1343. X
  1344. X
  1345. Xstatic void
  1346. Xenter_name(s, l)
  1347. Xchar *s;
  1348. Xint l;
  1349. X   {  /* enter a new cap into the name space list if it is new */
  1350. X      int i;
  1351. X      char *t, *f;
  1352. X
  1353. X      if (l == 0 | l >= NP_SIZE) return;
  1354. X      if (np[0] == NULL)
  1355. X         for (i = 0; i < NP_SIZE; i++) {
  1356. X            np[i] = &ns[sizeof(ns) - 1];
  1357. X         }
  1358. X         for (t = np[l - 1]; t < np[l]; t += l) {
  1359. X            if (!strncmp(t, s, l)) return;
  1360. X         }
  1361. X      /* a new entry */
  1362. X      if (np[0] - l < ns) return;  /* no room */
  1363. X      f = np[0];
  1364. X         for (t = np[0] - l; f < np[l - 1]; *t++ = *f++);
  1365. X         for (i = 0; i < l; i++) np[i] -= l;
  1366. X         for ( ; l--; *t++ = *s++);
  1367. X   }
  1368. X
  1369. X
  1370. Xvoid
  1371. Xcap_test(s)
  1372. Xchar *s;
  1373. X   {  /* routine for termcaps that have no terminfo equivalents */
  1374. X      if (s)
  1375. X         {
  1376. X            sprintf(temp, ":%s", s);
  1377. X            enter_name(temp, strlen(temp));
  1378. X         }
  1379. X   }
  1380. X
  1381. X
  1382. Xvoid
  1383. Xcan_test(s)
  1384. Xchar *s;
  1385. X   {  /* caps that are actually tested come here */
  1386. X      char *t;
  1387. X
  1388. X      if (!s) return;
  1389. X      if (*s != '(') {
  1390. X         enter_name(s, strlen(s));
  1391. X         return;
  1392. X      }
  1393. X         for ( ; ; ) {
  1394. X            for ( ; *s != '('; s++) {
  1395. X               if (!*s) return;
  1396. X            }
  1397. X            for (t = ++s; *s != ')'; s++) {
  1398. X               if (!*s) return;
  1399. X            }
  1400. X            if (s - t < NP_SIZE) enter_name(t, s - t);
  1401. X         }
  1402. X   }
  1403. X
  1404. X
  1405. X#ifdef TESTCAP
  1406. Xvoid
  1407. Xreport_known(nx, nc)
  1408. Xchar **nx;
  1409. Xint nc;
  1410. X   {  /* scan the termcap entry and report any unknown capibilities */
  1411. X      extern char cap_entry[];
  1412. X      int i, first_one;
  1413. X      char *s, *t;
  1414. X
  1415. X      ptextln("Termcap definition:");
  1416. X      t = temp;
  1417. X      expand_chars = 0;
  1418. X         for (s = cap_entry; *s; s++) {
  1419. X            if (*s == ':' && s[1] == '\t' && s[2] == ':')
  1420. X               {
  1421. X                  s += 2;
  1422. X                  if (expand_chars > 10) expand_chars = columns;
  1423. X               }
  1424. X            expand_one(*s, &t);
  1425. X            if (*s == ':' && expand_chars + 20 > columns)
  1426. X               {
  1427. X                  *t = '\0';
  1428. X                  put_str(temp);
  1429. X                  put_str("\\\n\t:");
  1430. X                  t = temp;
  1431. X                  expand_chars = 0;
  1432. X               }
  1433. X         }
  1434. X      *t = '\0';
  1435. X      if (temp[0]) put_str(temp);
  1436. X      put_crlf();
  1437. X      first_one = 1;
  1438. X         for (s = cap_entry; *s; ) {
  1439. X            /* find a : */
  1440. X               for ( ; *s && *s != ':'; s++);
  1441. X            if (!*s) break;
  1442. X            /* scan past white space */
  1443. X               for (s++; *s && (*s == ' ' || *s == '\t' || *s == '\n'); s++);
  1444. X            /* find the end of the cap name */
  1445. X               for (t = s; *s && *s != ':' && *s != '=' && *s != '#'; s++);
  1446. X            if (s != t)
  1447. X               for (i = 0; strncmp(nx[i], t, s - t) != 0; i++) {
  1448. X                  if (i >= nc)
  1449. X                     {
  1450. X                        if (first_one)
  1451. X                           ptextln("Untested termcap entries:");
  1452. X                        first_one = 0;
  1453. X                           for ( ; *s && *s != ':'; s++);
  1454. X                        strncpy(temp, t, s - t);
  1455. X                        temp[s - t] = '\0';
  1456. X                        ptext("    ");
  1457. X                        ptextln(temp);
  1458. X                        break;
  1459. X                     }
  1460. X               }
  1461. X         }
  1462. X      if (first_one)
  1463. X         ptextln("All termcap entries can be tested.");
  1464. X   }
  1465. X#endif
  1466. X
  1467. X
  1468. Xvoid
  1469. Xprint_reported(tested_caps)
  1470. Xint tested_caps;
  1471. X   {  /* print a list of caps that have been reported as testable */
  1472. X      int i, j, nc;
  1473. X      char *s, *nsp;
  1474. X      char *nx[1024];
  1475. X
  1476. X      nc = 0;
  1477. X      nsp = ns;
  1478. X         for (i = 1; i < NP_SIZE; i++) {
  1479. X               for (s = np[i - 1]; s < np[i]; s += i) {
  1480. X#ifdef TESTCAP
  1481. X                  if (*s == ':')
  1482. X                     {  /* already converted */
  1483. X                        strncpy(nx[nc++] = nsp, s + 1, i - 1);
  1484. X                        nsp[i - 1] = '\0';
  1485. X                        nsp += i;
  1486. X                     }
  1487. X                  else
  1488. X                     {
  1489. X                        j = cap_index(s, i);
  1490. X                        nx[nc++] = (j >= 0) ? &captrans[j][i + 1] : "?";
  1491. X                     }
  1492. X#else
  1493. X                  strncpy(nx[nc++] = nsp, s, i);
  1494. X                  nsp[i] = '\0';
  1495. X                  nsp += i + 1;
  1496. X#endif
  1497. X               }
  1498. X         }
  1499. X      /* sort */
  1500. X         for (i = 0; i < nc - 1; i++)
  1501. X            for (j = i + 1; j < nc; j++) {
  1502. X               if (strcmp(nx[i], nx[j]) > 0) {
  1503. X                  s = nx[i];  nx[i] = nx[j];
  1504. X                  nx[j] = s;
  1505. X               }
  1506. X            }
  1507. X#ifdef TESTCAP
  1508. X      /* smash out duplicates */
  1509. X         for (i = 0, j = 0; ; ) {
  1510. X            nx[i] = nx[j++];
  1511. X            if (j >= nc) break;
  1512. X            if (strcmp(nx[i], nx[j]) != 0) i++;
  1513. X         }
  1514. X      nc = i;
  1515. X      if (tested_caps) report_known(nx, nc);
  1516. X      else
  1517. X#endif
  1518. X         {
  1519. X            ptextln("The following capabilities can be tested by this program:");
  1520. X               for (i = 0; i < nc; i++) {
  1521. X                  sprintf(temp, "%s ", nx[i]);
  1522. X                  ptext(temp);
  1523. X               }
  1524. X            put_crlf();
  1525. X         }
  1526. X   }
  1527. END_OF_FILE
  1528. if test 23144 -ne `wc -c <'output.c'`; then
  1529.     echo shar: \"'output.c'\" unpacked with wrong size!
  1530. fi
  1531. # end of 'output.c'
  1532. fi
  1533. if test -f 'scan.c' -a "${1}" != "-c" ; then 
  1534.   echo shar: Will not clobber existing file \"'scan.c'\"
  1535. else
  1536. echo shar: Extracting \"'scan.c'\" \(7800 characters\)
  1537. sed "s/^X//" >'scan.c' <<'END_OF_FILE'
  1538. X/*
  1539. X** This software is Copyright (c) 1991 by Daniel Weaver.
  1540. X**
  1541. X** Permission is hereby granted to copy, distribute or otherwise
  1542. X** use any part of this package as long as you do not try to make
  1543. X** money from it or pretend that you wrote it.  This copyright
  1544. X** notice must be maintained in any copy made.
  1545. X**
  1546. X** Use of this software constitutes acceptance for use in an AS IS
  1547. X** condition. There are NO warranties with regard to this software.
  1548. X** In no event shall the author be liable for any damages whatsoever
  1549. X** arising out of or in connection with the use or performance of this
  1550. X** software.  Any use of this software is at the user's own risk.
  1551. X**
  1552. X**  If you make modifications to this software that you feel
  1553. X**  increases it usefulness for the rest of the community, please
  1554. X**  email the changes, enhancements, bug fixes as well as any and
  1555. X**  all ideas to me. This software is going to be maintained and
  1556. X**  enhanced as deemed necessary by the community.
  1557. X*/
  1558. X/* scan mode keyboard support */
  1559. X
  1560. X#include "curses.h"
  1561. X#include "ted.h"
  1562. X
  1563. Xextern char *getenv();
  1564. X
  1565. Xint scan_max;  /* length of longest scan code */
  1566. Xchar **scan_up, **scan_down, **scan_name;
  1567. Xint *scan_tested, *scan_length, *scan_value;
  1568. Xint shift_state;
  1569. Xstatic char *str;
  1570. X
  1571. X#define SHIFT_KEY 0x100
  1572. X#define CONTROL_KEY 0x200
  1573. X#define META_KEY 0x400
  1574. X#define CAPS_LOCK 0x800
  1575. X
  1576. Xstruct {
  1577. X    char *name;
  1578. X    int type;
  1579. X} scan_special[] = {
  1580. X    "<shift>", SHIFT_KEY,
  1581. X    "<left shift>", SHIFT_KEY,
  1582. X    "<right shift>", SHIFT_KEY,
  1583. X    "<control>", CONTROL_KEY,
  1584. X    "<left control>", CONTROL_KEY,
  1585. X    "<right control>", CONTROL_KEY,
  1586. X    "<meta>", META_KEY,
  1587. X    "<left meta>", META_KEY,
  1588. X    "<right meta>", META_KEY,
  1589. X    "<caps lock>", CAPS_LOCK,
  1590. X    "<tab>", '\t',
  1591. X    "<space>", ' ',
  1592. X    "<return>", '\r',
  1593. X    "<linefeed>", '\n',
  1594. X    "<formfeed>", '\f',
  1595. X    "<backspace>", '\b',
  1596. X    0, 0};
  1597. X
  1598. Xstatic void
  1599. Xscan_blanks()
  1600. X   {  /* scan past the white space */
  1601. X      while (*str == ' ' || *str == '\t') str++;
  1602. X   }
  1603. X
  1604. Xstatic char *
  1605. Xsmash()
  1606. X   {  /* convert a string to hex */
  1607. X      char *s, *t;
  1608. X      int ch, i, j;
  1609. X
  1610. X      t = s = str;
  1611. X         for (i = 0; ch = *str; str++) {
  1612. X            if (ch >= '0' && ch <= '9') j = ch - '0';
  1613. X            else
  1614. X            if (ch >= 'a' && ch <= 'f') j = 10 - 'a' + ch;
  1615. X            else
  1616. X            if (ch >= 'A' && ch <= 'F') j = 10 - 'A' + ch;
  1617. X            else
  1618. X            if (ch == ' ' || ch == '\t') break;
  1619. X            else continue;
  1620. X            if (i)
  1621. X            {
  1622. X               *s |= j;
  1623. X               s++;
  1624. X            }
  1625. X            else *s = j << 4;
  1626. X            i ^= 1;
  1627. X         }
  1628. X      *s = '\0';
  1629. X      return t;
  1630. X   }
  1631. X
  1632. Xvoid
  1633. Xscan_init(fn)
  1634. Xchar *fn;
  1635. X   {  /* read the scan mode key definitions */
  1636. X      char *s, *sl;
  1637. X      FILE *fp;
  1638. X      int ch, i, j;
  1639. X      char home[512];
  1640. X
  1641. X      if (str = getenv("HOME")) strcpy(home, str);
  1642. X      else home[0] = '\0';
  1643. X      fp = NULL;
  1644. X      if (str = getenv("KEYBOARD"))
  1645. X         {
  1646. X            if (!(fp = fopen(str, "r")) && home[0])
  1647. X               {
  1648. X                  sprintf(temp, "%s/.scan.%s", home, str);
  1649. X                  fp = fopen(temp, "r");
  1650. X               }
  1651. X         }
  1652. X      if (!fp)
  1653. X         {
  1654. X            sprintf(temp, ".scan.%s", fn);
  1655. X            fp = fopen(temp, "r");
  1656. X         }
  1657. X      if (!fp && home[0])
  1658. X         {
  1659. X            sprintf(temp, "%s/.scan.%s", home, fn);
  1660. X            fp = fopen(temp, "r");
  1661. X         }
  1662. X      if (!fp)
  1663. X         {
  1664. X            ptext("Unable to open scanfile: ");
  1665. X            ptextln(temp);
  1666. X            bye_kids(1);
  1667. X            return;
  1668. X         }
  1669. X
  1670. X      /* scan file format:
  1671. X
  1672. X         <down value> <up value> <name>
  1673. X
  1674. X         values are in hex.
  1675. X         <name> may be any string of characters
  1676. X
  1677. X       */
  1678. X      scan_up = (char **)malloc(sizeof(char *) * MAX_SCAN);
  1679. X      scan_down = (char **)malloc(sizeof(char *) * MAX_SCAN);
  1680. X      scan_name = (char **)malloc(sizeof(char *) * MAX_SCAN);
  1681. X      scan_tested = (int *)malloc(sizeof(int *) * MAX_SCAN);
  1682. X      scan_length = (int *)malloc(sizeof(int *) * MAX_SCAN);
  1683. X      scan_value = (int *)malloc(sizeof(int *) * MAX_SCAN);
  1684. X      scan_up[0] = scan_down[0] = scan_name[0] = (char *)0;
  1685. X      str = (char *)malloc(4096);  /* buffer space */
  1686. X      sl = str + 4000;  /* an upper limit */
  1687. X      scan_max = 1;
  1688. X         for (i = 0; ; ) {
  1689. X               for (s = str; (ch = getc(fp)) != EOF; ) {
  1690. X                  if (ch == '\n' || ch == '\r') break;
  1691. X                  *s++ = ch;
  1692. X               }
  1693. X            *s++ = '\0';
  1694. X            if (ch == EOF) break;
  1695. X            if (*str == '#' || *str == '\0') continue;
  1696. X            scan_down[i] = smash();
  1697. X            scan_blanks();
  1698. X            scan_up[i] = smash();
  1699. X            scan_blanks();
  1700. X            scan_name[i] = str;
  1701. X
  1702. X            scan_length[i] = strlen(scan_down[i]);
  1703. X            ch = strlen(scan_up[i]) + scan_length[i];
  1704. X            if (ch > scan_max) scan_max = ch;
  1705. X
  1706. X            scan_value[i] = scan_name[i][0];
  1707. X            if (scan_name[i][1]) /* multi-character name */
  1708. X               for (j = 0; scan_special[j].name; j++) {
  1709. X                  if (!strcmp(scan_name[i], scan_special[j].name))
  1710. X                     {
  1711. X                        scan_value[i] = scan_special[j].type;
  1712. X                        break;
  1713. X                     }
  1714. X               }
  1715. X
  1716. X            i++;
  1717. X            if (str > sl)
  1718. X               {
  1719. X                  str = (char *)malloc(4096);
  1720. X                  sl = str + 4000;
  1721. X               }
  1722. X            else str = s;
  1723. X         }
  1724. X      fclose(fp);
  1725. X#ifdef notdef
  1726. X         for (i = 0; scan_down[i]; i++) {
  1727. X             put_str(hex_expand_to(scan_down[i], 3));
  1728. X             put_str(hex_expand_to(scan_up[i], 3));
  1729. X             put_str("   ");
  1730. X             put_str(scan_name[i]);
  1731. X             put_crlf();
  1732. X         }
  1733. X    (void) wait_here();
  1734. X#endif
  1735. X   }
  1736. X
  1737. Xint
  1738. Xscan_key()
  1739. X   {  /* read a key and translate scan mode to ASCII */
  1740. X      int i, j, ch;
  1741. X      char buf[64];
  1742. X
  1743. X         for (i = 1; ; i++) {
  1744. X            ch = getchar();
  1745. X            if (ch == EOF) return EOF;
  1746. X            if (debug_fp)
  1747. X               {
  1748. X                  fprintf(debug_fp, "%02X ", ch);
  1749. X                  debug_char_count += 3;
  1750. X                  if (debug_char_count > 72)
  1751. X                     {
  1752. X                        fprintf(debug_fp, "\n");
  1753. X                        debug_char_count = 0;
  1754. X                     }
  1755. X               }
  1756. X            buf[i - 1] = ch;
  1757. X            buf[i] = '\0';
  1758. X            if (buf[0] & 0x80) /* scan up */
  1759. X               {
  1760. X                     for (j = 0; scan_up[j]; j++) {
  1761. X                        if (i == scan_length[j] &&
  1762. X                           !strcmp(buf, scan_up[j]))
  1763. X                           {
  1764. X                              i = 0;
  1765. X                              shift_state &= ~scan_value[j];
  1766. X                              break;
  1767. X                           }
  1768. X                     }
  1769. X                  continue;
  1770. X               }
  1771. X               for (j = 0; scan_down[j]; j++) {
  1772. X                  if (i == scan_length[j] && !strcmp(buf, scan_down[j]))
  1773. X                     {
  1774. X                        i = 0;
  1775. X                        shift_state |= scan_value[j];
  1776. X                        ch = scan_value[j];
  1777. X                        if (ch == CAPS_LOCK) shift_state ^= SHIFT_KEY;
  1778. X                        if (ch >= 256) break;
  1779. X                        if (shift_state & SHIFT_KEY)
  1780. X                           if (ch >= 0x60) ch -= 0x20;
  1781. X                           else
  1782. X                           if (ch >= 0x30 && ch <= 0x3f) ch -= 0x10;
  1783. X                        if (shift_state & CONTROL_KEY)
  1784. X                           if ((ch | 0x20) >= 0x60 &&
  1785. X                              (ch | 0x20) <= 0x7f)
  1786. X                              ch = (ch | 0x20) - 0x60;
  1787. X                        if (shift_state & META_KEY) ch |= 0x80;
  1788. X                        return ch;
  1789. X                     }
  1790. X               }
  1791. X            if (i > scan_max) i = 1;
  1792. X         }
  1793. X   }
  1794. END_OF_FILE
  1795. if test 7800 -ne `wc -c <'scan.c'`; then
  1796.     echo shar: \"'scan.c'\" unpacked with wrong size!
  1797. fi
  1798. # end of 'scan.c'
  1799. fi
  1800. echo shar: End of archive 6 \(of 7\).
  1801. cp /dev/null ark6isdone
  1802. MISSING=""
  1803. for I in 1 2 3 4 5 6 7 ; do
  1804.     if test ! -f ark${I}isdone ; then
  1805.     MISSING="${MISSING} ${I}"
  1806.     fi
  1807. done
  1808. if test "${MISSING}" = "" ; then
  1809.     echo You have unpacked all 7 archives.
  1810.     rm -f ark[1-9]isdone
  1811. else
  1812.     echo You still need to unpack the following archives:
  1813.     echo "        " ${MISSING}
  1814. fi
  1815. ##  End of shell archive.
  1816. exit 0
  1817.  
  1818. exit 0 # Just in case...
  1819. -- 
  1820. Kent Landfield                   INTERNET: kent@sparky.IMD.Sterling.COM
  1821. Sterling Software, IMD           UUCP:     uunet!sparky!kent
  1822. Phone:    (402) 291-8300         FAX:      (402) 291-4362
  1823. Please send comp.sources.misc-related mail to kent@uunet.uu.net.
  1824.